const RoleModel = require('../models/role.model');
const RoleMenuModel = require('../models/role-menu.model');
const MenuModel = require('../models/menu.model');
const logger = require('../utils/logger');
const Response = require('../utils/response');

class RoleController {
  // 创建角色
  async createRole(req, res) {
    try {
      const { name, code, description, status } = req.body;
      
      // 验证必填字段
      if (!name || !code) {
        return res.status(400).json(
          Response.error({
            code: 400,
            message: '参数错误：角色名称和编码为必填项'
          })
        );
      }
      
      // 检查角色名称是否已存在
      const nameExists = await RoleModel.isNameExists(name);
      if (nameExists) {
        return res.status(400).json(
          Response.error({
            code: 400,
            message: '参数错误：角色名称已存在'
          })
        );
      }
      
      // 检查角色编码是否已存在
      const codeExists = await RoleModel.isCodeExists(code);
      if (codeExists) {
        return res.status(400).json(
          Response.error({
            code: 400,
            message: '参数错误：角色编码已存在'
          })
        );
      }
      
      // 构建角色数据
      const roleData = {
        name,
        code,
        description,
        status: status !== undefined ? Number(status) : 1
      };
      
      // 创建角色
      const roleId = await RoleModel.create(roleData);
      
      // 获取创建后的角色数据
      const role = await RoleModel.findById(roleId);
      
      return res.status(201).json(
        Response.success({
          code: 201,
          message: '创建角色成功',
          data: role
        })
      );
    } catch (error) {
      logger.error('创建角色失败:', error);
      return res.status(500).json(
        Response.error({
          message: '系统错误：' + error.message
        })
      );
    }
  }
  
  // 更新角色
  async updateRole(req, res) {
    try {
      const { id } = req.params;
      const { name, description, status } = req.body;
      
      // 验证角色ID
      if (!id || isNaN(id)) {
        return res.status(400).json(
          Response.error({
            code: 400,
            message: '参数错误：无效的角色ID'
          })
        );
      }
      
      // 检查角色是否存在
      const existingRole = await RoleModel.findById(id);
      if (!existingRole) {
        return res.status(404).json(
          Response.error({
            code: 404,
            message: '资源不存在：角色不存在或已被删除'
          })
        );
      }
      
      // 如果更新名称，检查名称是否已存在
      if (name && name !== existingRole.name) {
        const nameExists = await RoleModel.isNameExists(name, id);
        if (nameExists) {
          return res.status(400).json(
            Response.error({
              code: 400,
              message: '参数错误：角色名称已存在'
            })
          );
        }
      }
      
      // 构建更新数据
      const roleData = {};
      
      if (name !== undefined) roleData.name = name;
      if (description !== undefined) roleData.description = description;
      if (status !== undefined) roleData.status = Number(status);
      
      // 更新角色
      const updated = await RoleModel.update(id, roleData);
      
      if (!updated) {
        return res.status(400).json(
          Response.error({
            code: 400,
            message: '操作失败：角色更新失败或没有变更'
          })
        );
      }
      
      // 获取更新后的角色数据
      const role = await RoleModel.findById(id);
      
      return res.status(200).json(
        Response.success({
          message: '更新角色成功',
          data: role
        })
      );
    } catch (error) {
      logger.error('更新角色失败:', error);
      return res.status(500).json(
        Response.error({
          message: '系统错误：' + error.message
        })
      );
    }
  }
  
  // 删除角色
  async deleteRole(req, res) {
    try {
      const { id } = req.params;
      
      // 验证角色ID
      if (!id || isNaN(id)) {
        return res.status(400).json(
          Response.error({
            code: 400,
            message: '参数错误：无效的角色ID'
          })
        );
      }
      
      // 检查角色是否存在
      const existingRole = await RoleModel.findById(id);
      if (!existingRole) {
        return res.status(404).json(
          Response.error({
            code: 404,
            message: '资源不存在：角色不存在或已被删除'
          })
        );
      }
      
      // 删除角色
      try {
        const deleted = await RoleModel.softDelete(id);
        
        if (!deleted) {
          return res.status(400).json(
            Response.error({
              code: 400,
              message: '操作失败：角色删除失败'
            })
          );
        }
        
        return res.status(200).json(
          Response.success({
            message: '删除角色成功'
          })
        );
      } catch (error) {
        // 处理特定的业务错误
        if (error.message.includes('存在关联用户')) {
          return res.status(400).json(
            Response.error({
              code: 400,
              message: '操作失败：' + error.message
            })
          );
        }
        throw error;
      }
    } catch (error) {
      logger.error('删除角色失败:', error);
      return res.status(500).json(
        Response.error({
          message: '系统错误：' + error.message
        })
      );
    }
  }
  
  // 获取角色详情
  async getRoleById(req, res) {
    try {
      const { id } = req.params;
      
      // 验证角色ID
      if (!id || isNaN(id)) {
        return res.status(400).json(
          Response.error({
            code: 400,
            message: '参数错误：无效的角色ID'
          })
        );
      }
      
      // 获取角色
      const role = await RoleModel.findById(id);
      
      if (!role) {
        return res.status(404).json(
          Response.error({
            code: 404,
            message: '资源不存在：角色不存在或已被删除'
          })
        );
      }
      
      return res.status(200).json(
        Response.success({
          data: role
        })
      );
    } catch (error) {
      logger.error('获取角色详情失败:', error);
      return res.status(500).json(
        Response.error({
          message: '系统错误：' + error.message
        })
      );
    }
  }
  
  // 获取角色列表
  async getRoles(req, res) {
    try {
      const { name, status, page = 1, size = 10 } = req.query;
      
      // 构建查询参数
      const params = {
        name,
        status: status !== undefined ? Number(status) : undefined,
        page: parseInt(page),
        size: parseInt(size)
      };
      
      // 获取角色列表
      const { list, total } = await RoleModel.findAll(params);
      
      return res.status(200).json(
        Response.success({
          data: {
            list,
            total,
            page: params.page,
            size: params.size
          }
        })
      );
    } catch (error) {
      logger.error('获取角色列表失败:', error);
      return res.status(500).json(
        Response.error({
          message: '系统错误：' + error.message
        })
      );
    }
  }

  // 角色菜单分配
  async assignMenus(req, res) {
    try {
      const { id } = req.params;
      const { menuIds } = req.body;
      
      // 验证角色ID
      if (!id || isNaN(id)) {
        return res.status(400).json(
          Response.error({
            code: 400,
            message: '参数错误：无效的角色ID'
          })
        );
      }

      // 验证菜单ID数组
      if (!Array.isArray(menuIds)) {
        return res.status(400).json(
          Response.error({
            code: 400,
            message: '参数错误：菜单ID必须是数组'
          })
        );
      }

      // 检查角色是否存在
      const role = await RoleModel.findById(id);
      if (!role) {
        return res.status(404).json(
          Response.error({
            code: 404,
            message: '资源不存在：角色不存在或已被删除'
          })
        );
      }

      // 验证所有菜单ID是否有效
      if (menuIds.length > 0) {
        for (const menuId of menuIds) {
          if (isNaN(menuId)) {
            return res.status(400).json(
              Response.error({
                code: 400,
                message: `参数错误：无效的菜单ID ${menuId}`
              })
            );
          }
          
          const menu = await MenuModel.findById(menuId);
          if (!menu) {
            return res.status(404).json(
              Response.error({
                code: 404,
                message: `资源不存在：菜单ID ${menuId} 不存在或已被删除`
              })
            );
          }
        }
      }

      // 分配菜单
      await RoleMenuModel.assignMenus(id, menuIds);
      
      // 获取更新后的菜单ID列表
      const assignedMenuIds = await RoleMenuModel.getRoleMenuIds(id);
      
      return res.status(200).json(
        Response.success({
          message: '菜单分配成功',
          data: {
            roleId: Number(id),
            menuIds: assignedMenuIds
          }
        })
      );
    } catch (error) {
      logger.error('角色菜单分配失败:', error);
      return res.status(500).json(
        Response.error({
          message: '系统错误：' + error.message
        })
      );
    }
  }

  // 获取角色菜单
  async getRoleMenus(req, res) {
    try {
      const { id } = req.params;
      
      // 验证角色ID
      if (!id || isNaN(id)) {
        return res.status(400).json(
          Response.error({
            code: 400,
            message: '参数错误：无效的角色ID'
          })
        );
      }
      
      // 检查角色是否存在
      const role = await RoleModel.findById(id);
      if (!role) {
        return res.status(404).json(
          Response.error({
            code: 404,
            message: '资源不存在：角色不存在或已被删除'
          })
        );
      }
      
      // 获取角色菜单
      const roleMenus = await RoleModel.getRoleMenus(id);
      
      return res.status(200).json(
        Response.success({
          data: roleMenus
        })
      );
    } catch (error) {
      logger.error('获取角色菜单失败:', error);
      return res.status(500).json(
        Response.error({
          message: '系统错误：' + error.message
        })
      );
    }
  }
}

module.exports = new RoleController(); 